home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / include / bits / stdio-lock.h < prev    next >
C/C++ Source or Header  |  2008-09-29  |  4KB  |  112 lines
  1. /* Thread package specific definitions of stream lock type.  NPTL version.
  2.    Copyright (C) 2000, 2001, 2002, 2003, 2007 Free Software Foundation, Inc.
  3.    This file is part of the GNU C Library.
  4.  
  5.    The GNU C Library is free software; you can redistribute it and/or
  6.    modify it under the terms of the GNU Lesser General Public
  7.    License as published by the Free Software Foundation; either
  8.    version 2.1 of the License, or (at your option) any later version.
  9.  
  10.    The GNU C Library is distributed in the hope that it will be useful,
  11.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.    Lesser General Public License for more details.
  14.  
  15.    You should have received a copy of the GNU Lesser General Public
  16.    License along with the GNU C Library; if not, write to the Free
  17.    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18.    02111-1307 USA.  */
  19.  
  20. #ifndef _BITS_STDIO_LOCK_H
  21. #define _BITS_STDIO_LOCK_H 1
  22.  
  23. #include <bits/libc-lock.h>
  24. #include <lowlevellock.h>
  25.  
  26.  
  27. /* The locking here is very inexpensive, even for inlining.  */
  28. #define _IO_lock_inexpensive    1
  29.  
  30. typedef struct { int lock; int cnt; void *owner; } _IO_lock_t;
  31.  
  32. #define _IO_lock_initializer { LLL_LOCK_INITIALIZER, 0, NULL }
  33.  
  34. #define _IO_lock_init(_name) \
  35.   ((_name) = (_IO_lock_t) _IO_lock_initializer , 0)
  36.  
  37. #define _IO_lock_fini(_name) \
  38.   ((void) 0)
  39.  
  40. #define _IO_lock_lock(_name) \
  41.   do {                                          \
  42.     void *__self = THREAD_SELF;                              \
  43.     if ((_name).owner != __self)                          \
  44.       {                                          \
  45.     lll_lock ((_name).lock, LLL_PRIVATE);                      \
  46.         (_name).owner = __self;                              \
  47.       }                                          \
  48.     ++(_name).cnt;                                  \
  49.   } while (0)
  50.  
  51. #define _IO_lock_trylock(_name) \
  52.   ({                                          \
  53.     int __result = 0;                                  \
  54.     void *__self = THREAD_SELF;                              \
  55.     if ((_name).owner != __self)                          \
  56.       {                                          \
  57.         if (lll_trylock ((_name).lock) == 0)                      \
  58.           {                                      \
  59.             (_name).owner = __self;                          \
  60.             (_name).cnt = 1;                              \
  61.           }                                      \
  62.         else                                      \
  63.           __result = EBUSY;                              \
  64.       }                                          \
  65.     else                                      \
  66.       ++(_name).cnt;                                  \
  67.     __result;                                      \
  68.   })
  69.  
  70. #define _IO_lock_unlock(_name) \
  71.   do {                                          \
  72.     if (--(_name).cnt == 0)                              \
  73.       {                                          \
  74.         (_name).owner = NULL;                              \
  75.     lll_unlock ((_name).lock, LLL_PRIVATE);                      \
  76.       }                                          \
  77.   } while (0)
  78.  
  79.  
  80.  
  81. #define _IO_cleanup_region_start(_fct, _fp) \
  82.   __libc_cleanup_region_start (((_fp)->_flags & _IO_USER_LOCK) == 0, _fct, _fp)
  83. #define _IO_cleanup_region_start_noarg(_fct) \
  84.   __libc_cleanup_region_start (1, _fct, NULL)
  85. #define _IO_cleanup_region_end(_doit) \
  86.   __libc_cleanup_region_end (_doit)
  87.  
  88. #if defined _LIBC && !defined NOT_IN_libc
  89.  
  90. # ifdef __EXCEPTIONS
  91. #  define _IO_acquire_lock(_fp) \
  92.   do {                                          \
  93.     _IO_FILE *_IO_acquire_lock_file                          \
  94.     __attribute__((cleanup (_IO_acquire_lock_fct)))                  \
  95.     = (_fp);                                  \
  96.     _IO_flockfile (_IO_acquire_lock_file);
  97. #  define _IO_acquire_lock_clear_flags2(_fp) \
  98.   do {                                          \
  99.     _IO_FILE *_IO_acquire_lock_file                          \
  100.     __attribute__((cleanup (_IO_acquire_lock_clear_flags2_fct)))          \
  101.     = (_fp);                                  \
  102.     _IO_flockfile (_IO_acquire_lock_file);
  103. # else
  104. #  define _IO_acquire_lock(_fp) _IO_acquire_lock_needs_exceptions_enabled
  105. #  define _IO_acquire_lock_clear_flags2(_fp) _IO_acquire_lock (_fp)
  106. # endif
  107. # define _IO_release_lock(_fp) ; } while (0)
  108.  
  109. #endif
  110.  
  111. #endif /* bits/stdio-lock.h */
  112.